home *** CD-ROM | disk | FTP | other *** search
/ Shareware Grab Bag / Shareware Grab Bag.iso / 002 / editc.arc / ED8.C < prev    next >
Encoding:
C/C++ Source or Header  |  1987-01-03  |  4.8 KB  |  280 lines
  1. /* ED8.C */
  2.  
  3. #include "ed0.c"
  4. #include "ed1.ccc"
  5. char    keybuf[MAXKEY];  /* macro buffer for keystroke record and replay */
  6. int    replay_count; /* how many times to replay */    
  7. int    replay_number; /* current replay number */
  8. int    replay_flag;  /* are we replaying from buffer? */
  9. int    record_flag;  /* are we recording to buffer? */
  10. int    key_position; /* current position in buffer */
  11. sysabort()    /*  abort replay of buffer */
  12. {
  13.     record_flag=NO;
  14.     replay_flag=NO;
  15.     key_position=0;
  16.     replay_number=0;
  17. }
  18. syscount(count) int count;    /* set number of replays */
  19. {
  20.     replay_count=count;
  21. }
  22. syscstat()
  23. {
  24. int c;
  25.     c=scr_csts();
  26.     if (c==0){        /* correction of original version */
  27.         return(-1);
  28.     }
  29.     else {
  30.         return(c);
  31.     }
  32. }
  33. syscin() /* extensively altered to permit recording and replay of buffer */
  34. {        
  35. int c;
  36.     if (replay_flag==YES) {  /* proceed if we are replaying */
  37.         if ((c=syscstat())>0) {
  38.             pmtmode("       "); /* abort replay if key pressed */
  39.             record_flag=NO;
  40.             replay_flag=NO;
  41.             key_position=0;
  42.             replay_number=0;
  43.             return(c);
  44.         }
  45.         else {
  46.             c=keybuf[key_position++]; /* otherwise replay */
  47.             if (c==EOS) {
  48.                 key_position=0;
  49.                 if((++replay_number)==replay_count) {
  50.                     pmtmode("        "); /* finished */
  51.                     replay_flag=NO;
  52.                     replay_number=0;
  53.                 }
  54.             }
  55.             return(c);
  56.         }
  57.     }
  58.     else {
  59.         while ((c=scr_ci())==0) {
  60.             ;
  61.         }
  62.         if (c==RECORD) {
  63.             if (record_flag==NO) {  /* begin record */
  64.                 pmtmode("record");
  65.                 record_flag=YES;
  66.                 replay_flag=NO;
  67.                 key_position=0;
  68.                 keybuf[key_position]=EOS;
  69.             }
  70.             else {
  71.                 pmtmode("end record"); /* end record */
  72.                 record_flag=NO;
  73.             }
  74.             return(c);
  75.         }
  76.         else if (c==REPLAY) {  /* start replay */
  77.             pmtmode("replay");
  78.             replay_flag=YES;
  79.             record_flag=NO;
  80.             replay_number=0;
  81.             key_position=0;
  82.             return(c);
  83.         }
  84.         else if (record_flag==YES) {
  85.             if (key_position<MAXKEY1) {
  86.                 keybuf[key_position++]=c;
  87.                 keybuf[key_position]=EOS;
  88.                 return(c);
  89.             }
  90.             else {
  91.                 record_flag=NO;
  92.                 key_position=0;
  93.                 keybuf[key_position]=EOS;
  94.                 error("record overflow");
  95.                 return(c);
  96.             }
  97.         }
  98.         else  {
  99.             return(c);
  100.         }
  101.     }
  102. }
  103. syscout(c) char c;
  104. {
  105.     scr_co(c);
  106.     return(c);
  107. }
  108. syslout(c) char c;
  109. {
  110.     _os(5,c);
  111.     return(c);
  112. }
  113. sysend()
  114. {
  115.     return(_showsp()-200);
  116. }    /* added */
  117. syscreate(name) char *name;
  118. {
  119. int file;
  120.     if ((file=creat(name))==0) {
  121.         return(ERR);
  122.     }
  123.     else {
  124.         return(file);
  125.     }
  126. }
  127. sysopen(name,mode) char *name, *mode;
  128. {
  129. int file;
  130.     if ((file=fopen(name,mode))==0) {
  131.         return(ERR);
  132.     }
  133.     else {
  134.         return(file);
  135.     }
  136. }
  137. sysclose(file) int file;
  138. {
  139.     close(file);
  140.     return(OK);
  141. }
  142. sysrdch(file) int file;
  143. {
  144. int c;
  145.     if ((c=getc(file))==-1) {
  146.         return(EOF);
  147.     }
  148.     else if (c==LF) {    
  149.         if ((c=getc(file))==-1) {
  150.             return(EOF);
  151.             }
  152.     }
  153.     return(c);
  154. }
  155. syspshch(c,file) char c; int file;
  156. {
  157.     if (putc(c,file)==-1) {    
  158.             error("disk write failed");
  159.             return(ERR);
  160.     }
  161.     if (c==CR) {
  162.         if (putc(LF,file)==-1) {
  163.         error("disk write failed");
  164.         return(ERR);
  165.         }
  166.     }
  167.     return(c);
  168. }
  169. syspopch(file) int file;
  170. {
  171.     error("syspopch() not implemented");
  172.     return(ERR);
  173. }
  174. syschkfn(args) char *args;
  175. {
  176.     if (args[0] == EOS) {    /* add check for zero-length file name */
  177.         message("no file name");
  178.         return(ERR);
  179.     }
  180.     else {
  181.         return(OK);
  182.     }
  183. }
  184. syscopfn(args,buffer) char *args, *buffer;
  185. {
  186. int n;
  187.     n=0;
  188.     while (n<SYSFNMAX-1) {
  189.         if (args[n]==EOS) {
  190.             break;
  191.         }
  192.         else {
  193.             buffer[n]=args[n];
  194.             n++;
  195.         }
  196.     }
  197.     buffer[n]=EOS;
  198. }
  199. sysdnmov(n,d,s) int n,*d,*s;
  200. {
  201.     if (n==0) {
  202.         return;
  203.     }
  204.     _move(n,s,d);
  205. }    /* added */
  206. sysupmov (n,d,s) int n,*d,*s;
  207. {
  208.     if (n==0) {
  209.         return;
  210.     }
  211.     _move(n,s,d);
  212. }    /* added */
  213. amatch (a,b,c) int a,b,c;
  214. /* matches pattern at b to line at a
  215.    all all question marks match
  216.    if flag c is NO match is only at beginning of line
  217. */
  218. {
  219. #asm
  220.     mov    bx,[bp+06]
  221.     mov    dx,[bp+04]
  222.     mov    al,[bx]
  223.     cmp    al,0
  224.     je    no_match
  225.     mov    cx,0
  226.     mov    si,[bp+04]
  227. cycles:    mov    ah,[si]
  228.     cmp    ah,0
  229.     je    no_match
  230.     cmp    al,ah
  231.     jne    not_so_far
  232. reprieve:    inc    bx
  233.     inc    si
  234.     mov    al,[bx]
  235.     cmp    al,0
  236.     je    success
  237.     jmp    cycles
  238. not_so_far:    cmp    al,'?'
  239.     je    reprieve
  240.     mov    ax,[bp+08]
  241.     cmp    ax,0
  242.     je    no_match
  243.     inc    dx
  244.     inc    cx
  245.     mov    si,dx
  246.     mov    bx,[bp+06]
  247.     mov    al,[bx]
  248.     jmp    cycles
  249. success:    mov    ax,cx
  250.     jmp    returns
  251. no_match:    mov    ax,0ffffh
  252. returns:    nop
  253. #
  254. }
  255. sysdelay()
  256. {
  257. }
  258. sysinit()
  259. {
  260.     scr_setup(); /* start things up & initialize */
  261.     scr_setmode(3);
  262.     scr_clr();
  263.     scr_chr_attr(SETNORMAL);
  264.     scr_chr_attr(SETFAINT);
  265.     scr_chr_attr(NOBLINK);
  266.     replay_flag=NO;
  267.     record_flag=NO;
  268.     replay_count=1;
  269.     keybuf[0]=EOS;
  270.     key_position=0;
  271. }
  272. sysfinish()
  273. {
  274.     scr_chr_attr(SETNORMAL); /* finish up loose ends */
  275.     scr_chr_attr(SETFAINT);
  276.     scr_chr_attr(NOBLINK);
  277.     scr_clr();
  278.     scr_rowcol(0,0);
  279. }
  280.